Python Ast Modülü: Soyut Sözdizimi Ağacı Manipülasyonu Çözümlendi

Python ast modülü, Python kodunun soyut sözdizimi ağacı (AST) ile etkileşim kurmanın güçlü bir yolunu sunar. AST, kaynak kodunun sözdizimsel yapısının bir ağaç gösterimidir ve Python kodunu programlı olarak analiz etmeyi, değiştirmeyi ve hatta oluşturmayı mümkün kılar. Bu, kod analizi araçları, otomatik yeniden düzenleme, statik analiz ve hatta özel dil uzantıları dahil olmak üzere çeşitli uygulamaların kapılarını açar. Bu makale, pratik örnekler ve yeteneklerine ilişkin içgörüler sağlayarak, ast modülünün temelleri konusunda size rehberlik edecektir.

Soyut Sözdizimi Ağacı (AST) Nedir?

ast modülüne dalmadan önce, Soyut Sözdizimi Ağacının ne olduğunu anlayalım. Bir Python yorumlayıcısı kodunuzu yürüttüğünde, ilk adım kodu bir AST'ye ayrıştırmaktır. Bu ağaç yapısı, işlevler, sınıflar, döngüler, ifadeler ve işleçler gibi kodun sözdizimsel öğelerini ilişkileriyle birlikte temsil eder. AST, boşluk ve yorumlar gibi alakasız ayrıntıları atar ve temel yapısal bilgilere odaklanır. Kodu bu şekilde temsil ederek, programların kodun kendisini analiz etmesi ve değiştirmesi mümkün hale gelir, bu da birçok durumda son derece yararlıdır.

ast Modülünü Kullanmaya Başlama

ast modülü, Python'ın standart kitaplığının bir parçasıdır, bu nedenle herhangi bir ek paket yüklemenize gerek yoktur. Kullanmaya başlamak için onu içe aktarın:

            import ast
            

              
                Copy
              
            
          

ast modülünün temel işlevi, Python kodunun bir dizesini girdi olarak alan ve bir AST nesnesi döndüren ast.parse() işlevidir.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast_tree)
            

              
                Copy
              
            
          

Bu, şuna benzer bir çıktı verecektir: <_ast.Module object at 0x...>. Bu çıktı özellikle bilgilendirici olmasa da, kodun bir AST'ye başarıyla ayrıştırıldığını gösterir. ast_tree nesnesi artık ayrıştırılmış kodun tüm yapısını içerir.

AST'yi Keşfetme

AST'nin yapısını anlamak için ast.dump() işlevini kullanabiliriz. Bu işlev, ağacı yinelemeli olarak gezer ve her düğümün ayrıntılı bir gösterimini yazdırır.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast.dump(ast_tree, indent=4))
            

              
                Copy
              
            
          

Çıktı şöyle olacaktır:

            Module(
    body=[
        FunctionDef(
            name='add',
            args=arguments(
                posonlyargs=[],
                args=[
                    arg(arg='x', annotation=None, type_comment=None),
                    arg(arg='y', annotation=None, type_comment=None)
                ],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                Return(
                    value=BinOp(
                        left=Name(id='x', ctx=Load()),
                        op=Add(),
                        right=Name(id='y', ctx=Load())
                    )
                )
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    type_ignores=[]
)
            

              
                Copy
              
            
          

Bu çıktı, kodun hiyerarşik yapısını gösterir. Hadi parçalayalım:

• Module: Tüm modülü temsil eden kök düğüm.
• body: Modül içindeki ifadelerin bir listesi.
• FunctionDef: Bir fonksiyon tanımını temsil eder. Özellikleri şunları içerir:
• name: Fonksiyonun adı ('add').
• args: Fonksiyonun argümanları.
• arguments: Fonksiyonun argümanları hakkında bilgi içerir.
• arg: Tek bir argümanı temsil eder (örn. 'x', 'y').
• body: Fonksiyonun gövdesi (bir ifade listesi).
• Return: Bir dönüş ifadesini temsil eder.
• value: Döndürülen değer.
• BinOp: İkili bir işlemi temsil eder (örn. x + y).
• left: Sol işlenen (örn. 'x').
• op: İşleç (örn. 'Add').
• right: Sağ işlenen (örn. 'y').

AST'yi Geçme

ast modülü, AST'yi geçmek için ast.NodeVisitor sınıfını sağlar. ast.NodeVisitor sınıfını alt sınıflayarak ve yöntemlerini geçersiz kılarak, geçiş sırasında karşılaşıldıklarında belirli düğüm türlerini işleyebilirsiniz. Bu, kod yapısını analiz etmek, belirli desenleri belirlemek veya bilgi çıkarmak için kullanışlıdır.

            import ast

class FunctionNameExtractor(ast.NodeVisitor):
    def __init__(self):
        self.function_names = []

    def visit_FunctionDef(self, node):
        self.function_names.append(node.name)

code = """
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y
"""

ast_tree = ast.parse(code)

extractor = FunctionNameExtractor()
extractor.visit(ast_tree)

print(extractor.function_names)  # Output: ['add', 'subtract']
            

              
                Copy
              
            
          

Bu örnekte, FunctionNameExtractor, ast.NodeVisitor sınıfından miras alır ve visit_FunctionDef yöntemini geçersiz kılar. Bu yöntem, AST'deki her fonksiyon tanımı düğümü için çağrılır. Yöntem, fonksiyon adını function_names listesine ekler. visit() yöntemi, AST'nin geçişini başlatır.

Örnek: Tüm değişken atamalarını bulma

            import ast

class VariableAssignmentFinder(ast.NodeVisitor):
    def __init__(self):
        self.assignments = []

    def visit_Assign(self, node):
        for target in node.targets:
            if isinstance(target, ast.Name):
                self.assignments.append(target.id)

code = """
x = 10
y = x + 5
message = "hello"
"""

ast_tree = ast.parse(code)

finder = VariableAssignmentFinder()
finder.visit(ast_tree)

print(finder.assignments)  # Output: ['x', 'y', 'message']
            

              
                Copy
              
            
          

Bu örnek, koddaki tüm değişken atamalarını bulur. visit_Assign yöntemi, her atama ifadesi için çağrılır. Atamanın hedeflerini yineler ve bir hedef basit bir ad (ast.Name) ise, adı assignments listesine ekler.

AST'yi Değiştirme

ast modülü ayrıca AST'yi değiştirmenize de olanak tanır. Mevcut düğümleri değiştirebilir, yeni düğümler ekleyebilir veya düğümleri tamamen kaldırabilirsiniz. AST'yi değiştirmek için ast.NodeTransformer sınıfını kullanırsınız. ast.NodeVisitor'a benzer şekilde, ast.NodeTransformer sınıfını alt sınıflar ve belirli düğüm türlerini değiştirmek için yöntemlerini geçersiz kılarsınız. Temel fark, ast.NodeTransformer yöntemlerinin değiştirilmiş düğümü (veya onu değiştirmek için yeni bir düğümü) döndürmesi gerektiğidir. Bir yöntem None döndürürse, düğüm AST'den kaldırılır.

AST'yi değiştirdikten sonra, compile() fonksiyonunu kullanarak onu tekrar yürütülebilir Python koduna derlemeniz gerekir.

            import ast

class AddOneTransformer(ast.NodeTransformer):
    def visit_Num(self, node):
        return ast.Num(n=node.n + 1)

code = """
x = 10
y = 20
"""

ast_tree = ast.parse(code)

transformer = AddOneTransformer()
new_ast_tree = transformer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

print(x)  # Output: 11
print(y)  # Output: 21
            

              
                Copy
              
            
          

Bu örnekte, AddOneTransformer, ast.NodeTransformer sınıfından miras alır ve visit_Num yöntemini geçersiz kılar. Bu yöntem, her sayısal değişmez düğümü (ast.Num) için çağrılır. Yöntem, değeri 1 artırılmış yeni bir ast.Num düğümü oluşturur. visit() yöntemi, değiştirilmiş AST'yi döndürür.

compile() fonksiyonu, değiştirilmiş AST'yi, bir dosya adını (bu durumda <string>, kodun bir dizeden geldiğini gösterir) ve bir yürütme modunu (bir kod bloğunu yürütmek için 'exec') alır. exec() fonksiyonu kullanılarak yürütülebilen bir kod nesnesi döndürür.

Örnek: Bir değişken adını değiştirme

            import ast

class VariableNameReplacer(ast.NodeTransformer):
    def __init__(self, old_name, new_name):
        self.old_name = old_name
        self.new_name = new_name

    def visit_Name(self, node):
        if node.id == self.old_name:
            return ast.Name(id=self.new_name, ctx=node.ctx)
        return node

code = """
def multiply_by_two(number):
    return number * 2

result = multiply_by_two(5)
print(result)
"""

ast_tree = ast.parse(code)

replacer = VariableNameReplacer('number', 'num')
new_ast_tree = replacer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

            

              
                Copy
              
            
          

Bu örnek, 'number' değişken adının tüm oluşumlarını 'num' ile değiştirir. VariableNameReplacer, eski ve yeni adları argüman olarak alır. visit_Name yöntemi, her ad düğümü için çağrılır. Düğümün tanımlayıcısı eski adla eşleşirse, yeni ad ve aynı bağlam (node.ctx) ile yeni bir ast.Name düğümü oluşturur. Bağlam, adın nasıl kullanıldığını gösterir (örn. yükleme, depolama).

Bir AST'den Kod Oluşturma

compile(), bir AST'den kodu yürütmenize izin verirken, kodu bir dize olarak almanın bir yolunu sağlamaz. Bir AST'den Python kodu oluşturmak için astunparse kitaplığını kullanabilirsiniz. Bu kitaplık standart kitaplığın bir parçası değildir, bu nedenle önce yüklemeniz gerekir:

            pip install astunparse
            

              
                Copy
              
            
          

Ardından, bir AST'den kod oluşturmak için astunparse.unparse() fonksiyonunu kullanabilirsiniz.

            import ast
import astunparse

code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)

generated_code = astunparse.unparse(ast_tree)

print(generated_code)
            

              
                Copy
              
            
          

Çıktı şöyle olacaktır:

            def add(x, y):
    return (x + y)

            

              
                Copy
              
            
          

Not: (x + y) etrafındaki parantezler, doğru operatör önceliğini sağlamak için astunparse tarafından eklenir. Bu parantezler kesinlikle gerekli olmayabilir, ancak kodun doğruluğunu garanti ederler.

Örnek: Basit bir sınıf oluşturma

            import ast
import astunparse

class_name = 'MyClass'
method_name = 'my_method'

# Create the class definition node
class_def = ast.ClassDef(
    name=class_name,
    bases=[],
    keywords=[],
    body=[
        ast.FunctionDef(
            name=method_name,
            args=ast.arguments(
                posonlyargs=[],
                args=[],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                ast.Pass()
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    decorator_list=[]
)

# Create the module node containing the class definition
module = ast.Module(body=[class_def], type_ignores=[])

# Generate the code
code = astunparse.unparse(module)

print(code)
            

              
                Copy
              
            
          

Bu örnek, aşağıdaki Python kodunu oluşturur:

            class MyClass:

    def my_method():
        pass

            

              
                Copy
              
            
          

Bu, sıfırdan bir AST'nin nasıl oluşturulacağını ve ardından ondan nasıl kod oluşturulacağını gösterir. Bu yaklaşım, kod oluşturma araçları ve metaprogramlama için güçlüdür.

ast Modülünün Pratik Uygulamaları

ast modülünün çok sayıda pratik uygulaması vardır, bunlar arasında:

• Kod Analizi: Stil ihlalleri, güvenlik açıkları veya performans darboğazları için kodu analiz etme. Örneğin, büyük bir proje genelinde kodlama standartlarını uygulamak için bir araç yazabilirsiniz.
• Otomatik Yeniden Düzenleme: Değişkenleri yeniden adlandırma, yöntemleri çıkarma veya kodu daha yeni dil özelliklerini kullanacak şekilde dönüştürme gibi görevleri otomatikleştirme. `rope` gibi araçlar, güçlü yeniden düzenleme yetenekleri için AST'lerden yararlanır.
• Statik Analiz: Kodu gerçekten çalıştırmadan potansiyel hataları veya hataları tanımlama. `pylint` ve `flake8` gibi araçlar, sorunları tespit etmek için AST analizini kullanır.
• Kod Üretimi: Şablonlara veya spesifikasyonlara göre otomatik olarak kod oluşturma. Bu, tekrarlayan kod oluşturmak veya farklı platformlar için kod oluşturmak için kullanışlıdır.
• Dil Uzantıları: Python kodunu farklı gösterimlere dönüştürerek özel dil uzantıları veya alana özgü diller (DSL'ler) oluşturma.
• Güvenlik Denetimi: Potansiyel olarak zararlı yapıları veya güvenlik açıklarını bulmak için kodu analiz etme. Bu, güvenli olmayan kodlama uygulamalarını belirlemek için kullanılabilir.

Örnek: Kodlama Stilini Uygulama

Projenizdeki tüm fonksiyon adlarının snake_case kuralını (örn. myFunction yerine my_function) izlemesini istediğinizi varsayalım. İhlalleri kontrol etmek için ast modülünü kullanabilirsiniz.

            import ast
import re

class SnakeCaseChecker(ast.NodeVisitor):
    def __init__(self):
        self.errors = []

    def visit_FunctionDef(self, node):
        if not re.match(r'^[a-z]+(_[a-z]+)*$', node.name):
            self.errors.append(f"Function name '{node.name}' does not follow snake_case convention")

    def check_code(self, code):
        ast_tree = ast.parse(code)
        self.visit(ast_tree)
        return self.errors

# Example usage
code = """
def myFunction(x):
    return x * 2

def calculate_area(width, height):
    return width * height
"""

checker = SnakeCaseChecker()
errors = checker.check_code(code)

if errors:
    for error in errors:
        print(error)
else:
    print("No style violations found")
            

              
                Copy
              
            
          

Bu kod, ast.NodeVisitor sınıfından miras alan bir SnakeCaseChecker sınıfı tanımlar. visit_FunctionDef yöntemi, fonksiyon adının snake_case normal ifadesiyle eşleşip eşleşmediğini kontrol eder. Eşleşmiyorsa, errors listesine bir hata mesajı ekler. check_code yöntemi, kodu ayrıştırır, AST'yi gezer ve hata listesini döndürür.

ast Modülüyle Çalışırken En İyi Uygulamalar

• AST Yapısını Anlayın: AST'yi değiştirmeye çalışmadan önce, ast.dump() kullanarak yapısını anlamaya zaman ayırın. Bu, çalışmanız gereken düğümleri belirlemenize yardımcı olacaktır.
• ast.NodeVisitor ve ast.NodeTransformer Kullanın: Bu sınıflar, ağaçta manuel olarak gezinmek zorunda kalmadan AST'yi geçmenin ve değiştirmenin uygun bir yolunu sağlar.
• İyice Test Edin: AST'yi değiştirirken, değişikliklerin doğru olduğundan ve herhangi bir hata getirmediğinden emin olmak için kodunuzu iyice test edin.
• Kod Oluşturma için astunparse'ı Düşünün: compile() değiştirilmiş kodu yürütmek için kullanışlı olsa da, astunparse bir AST'den okunabilir Python kodu oluşturmanın bir yolunu sağlar.
• Tür İpuçlarını Kullanın: Tür ipuçları, özellikle karmaşık AST yapılarıyla çalışırken kodunuzun okunabilirliğini ve sürdürülebilirliğini önemli ölçüde artırabilir.
• Kodunuzu Belgeleyin: Özel AST ziyaretçileri veya dönüştürücüleri oluştururken, her yöntemin amacını ve AST'de yaptığı değişiklikleri açıklamak için kodunuzu açıkça belgeleyin.

Zorluklar ve Dikkat Edilmesi Gerekenler

• Karmaşıklık: AST'lerle çalışmak, özellikle daha büyük kod tabanları için karmaşık olabilir. Farklı düğüm türlerini ve bunların ilişkilerini anlamak zor olabilir.
• Bakım: AST yapıları, Python sürümleri arasında değişebilir. Uyumluluğu sağlamak için kodunuzu farklı Python sürümleriyle test ettiğinizden emin olun.
• Performans: Büyük AST'leri geçmek ve değiştirmek yavaş olabilir. Performansı artırmak için kodunuzu optimize etmeyi düşünün. Sık erişilen düğümleri önbelleğe almak veya daha verimli algoritmalar kullanmak yardımcı olabilir.
• Hata Yönetimi: AST'yi ayrıştırırken veya manipüle ederken hataları düzgün bir şekilde ele alın. Kullanıcıya bilgilendirici hata mesajları sağlayın.
• Güvenlik: Özellikle AST kullanıcı girdisine dayanıyorsa, bir AST'den oluşturulan kodu yürütürken dikkatli olun. Kod enjeksiyonu saldırılarını önlemek için girdiyi temizleyin.

Sonuç

Python ast modülü, Python kodunun soyut sözdizimi ağacıyla etkileşim kurmanın güçlü ve esnek bir yolunu sağlar. AST yapısını anlayarak ve ast.NodeVisitor ve ast.NodeTransformer sınıflarını kullanarak, Python kodunu programlı olarak analiz edebilir, değiştirebilir ve oluşturabilirsiniz. Bu, kod analizi araçlarından otomatik yeniden düzenlemeye ve hatta özel dil uzantılarına kadar çok çeşitli uygulamaların kapılarını açar. AST'lerle çalışmak karmaşık olsa da, kodu programlı olarak manipüle edebilmenin faydaları önemlidir. Python projelerinizde yeni olanakların kilidini açmak için ast modülünün gücünü kucaklayın.